#include <iostream>     // 用于标准输入输出 cin, cout
#include <vector>       // 用于动态数组 std::vector (邻接表)
#include <queue>        // 用于队列 std::queue (BFS)
#include <algorithm>    // 用于排序 std::sort
#include <bitset>       // 用于位集合 std::bitset

// 定义城市数量的最大值，并留一些余量
const int MAXN_CITIES = 50000 + 10;

// adj[i] 存储城市 i 的所有邻居城市
std::vector<int> adj[MAXN_CITIES];
// recorded_dist[i]：Malnar 记录的从城市 i 到酒店的最短路径长度。
// 如果 Malnar 没有记录这个值，则为 -1。
int recorded_dist[MAXN_CITIES];
// derived_dist[i]：算法推导出的从城市 i 到酒店的路径长度。
// 对于没有记录距离的城市，它们在被访问前此值默认为 0 (或未初始化)。
int derived_dist[MAXN_CITIES];
// visited_in_bfs[i]：标记城市 i 是否已被加入BFS队列并进行过主要处理。
bool visited_in_bfs[MAXN_CITIES];
// cities_by_dist[k]：存储所有满足 recorded_dist[i] == k 的城市 i 的列表。
// 便于快速查找具有特定记录距离的城市。
std::vector<int> cities_by_dist[MAXN_CITIES];
// constraints_satisfied[i]：位集合。
// 如果 constraints_satisfied[i] 的第 k 位被设置，
// 表示：假设城市 i 位于某条到酒店的路径上，且距离酒店 derived_dist[i]，
// 那么 Malnar 对城市 k 的记录 (recorded_dist[k]) 与这个假设是相容的。
// 注意：bitset 的索引通常从0开始，如果城市编号从1开始，使用时需要注意映射。
// 此处代码似乎直接用城市编号k作为bitset的位索引，所以bitset大小要能容纳最大城市编号。
std::bitset<MAXN_CITIES> constraints_satisfied[MAXN_CITIES];
// BFS 算法使用的队列
std::queue<int> q;

// 全局标记，如果发现任何距离矛盾，则设为 false
bool possible_to_find_hotel = true;
// Malnar 记录了距离的城市总数
int num_cities_with_recorded_dist = 0;

// 执行 BFS-like 算法来推导距离并检查一致性
void solve_bfs() {
    while (!q.empty()) {
        int u = q.front(); // 当前处理的城市 u
        q.pop();

        // 如果 derived_dist[u] 为 0, 说明 u 是一个潜在的酒店位置。
        // 不需要从酒店再“向回”传播（即到距离为 -1 的城市）。
        if (derived_dist[u] == 0) {
            continue;
        }

        // 处理那些根据 recorded_dist 应该在 derived_dist[u] - 1 距离的城市。
        // 这一步确保了有记录距离的城市其 derived_dist 被“锚定”到它们的记录值。
        int target_dist_for_constrained_cities = derived_dist[u] - 1;
        if (target_dist_for_constrained_cities >= 0) { // 确保距离不是负数
            // 遍历所有 recorded_dist[v] == target_dist_for_constrained_cities 的城市 v
            // 原始AC代码中这里是从vector尾部pop，确保只处理一次
            while (!cities_by_dist[target_dist_for_constrained_cities].empty()) {
                int v = cities_by_dist[target_dist_for_constrained_cities].back();
                // 从列表中移除，确保每个这样的城市只通过此方式处理一次
                cities_by_dist[target_dist_for_constrained_cities].pop_back();

                if (visited_in_bfs[v]) {
                    // 如果 v 已经被访问过（例如，其 derived_dist[v] 是通过路径传播设置的），
                    // 那么这个 derived_dist[v] 必须与其自身的 recorded_dist[v] 相符。
                    if (recorded_dist[v] != derived_dist[v]) { // recorded_dist[v] 应该等于 target_dist_for_constrained_cities
                        possible_to_find_hotel = false; // 发现矛盾
                    }
                } else {
                    // 如果 v 未被访问过，根据其 recorded_dist 设置 derived_dist。
                    visited_in_bfs[v] = true;
                    derived_dist[v] = recorded_dist[v]; // recorded_dist[v] 即 target_dist_for_constrained_cities
                    constraints_satisfied[v].set(v); // 城市 v 满足其自身的约束 (第v位置1)
                    q.push(v); // 将 v 加入队列进一步处理
                }
            }
        }

        // 将距离信息传播给 u 的邻居。
        // 如果城市 u 距离酒店 derived_dist[u]，那么其邻居 v 应该距离酒店 derived_dist[u] - 1。
        for (int v : adj[u]) {
            // 这个条件 (derived_dist[v] < derived_dist[u]) 来自原始AC代码。
            // 它的含义是：只有当 v 的当前推导距离 derived_dist[v] 比 u 的推导距离 derived_dist[u] 要小
            // (比如 v 未被初始化，derived_dist[v]是0，或者v已经被更新为 derived_dist[u]-1)
            // 且如果 v 将被更新为 derived_dist[u]-1，这个更新是有意义的或保持一致的。
            // 一个更直接的理解是，如果 v 可以是 u 前面的一个点，则更新。
            if (derived_dist[v] < derived_dist[u]) { // 关键：确保我们是向酒店靠近的方向更新
                derived_dist[v] = derived_dist[u] - 1; // 设置/更新 v 的 derived_dist
                // v 现在也必须满足 u 所满足的所有约束。
                constraints_satisfied[v] |= constraints_satisfied[u];

                if (!visited_in_bfs[v]) {
                    // 如果 v 还没有通过队列被正式处理过 (主要指其 derived_dist 不是因 recorded_dist 而固定的情况)，
                    // 则将其加入队列。
                    q.push(v);
                    visited_in_bfs[v] = true;
                }
            }
        }
    }
}

int main() {
    // 使用标准C++流；解除cin与cout的绑定以加快I/O速度。
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    int n_cities, n_roads;
    std::cin >> n_cities >> n_roads;

    for (int i = 0; i < n_roads; ++i) {
        int u, v_node; // 避免与标准库的v冲突，使用v_node
        std::cin >> u >> v_node;
        adj[u].push_back(v_node);
        adj[v_node].push_back(u);
    }

    int max_recorded_dist_val = -1; // 记录下的最大距离值
    for (int i = 1; i <= n_cities; ++i) {
        std::cin >> recorded_dist[i];
        if (recorded_dist[i] != -1) {
            cities_by_dist[recorded_dist[i]].push_back(i);
            num_cities_with_recorded_dist++;
            if (recorded_dist[i] > max_recorded_dist_val) {
                max_recorded_dist_val = recorded_dist[i];
            }
        }
    }

    // 特殊情况：如果 Malnar 没有记录任何距离，则任何城市都可以是酒店。
    if (num_cities_with_recorded_dist == 0) {
        std::cout << n_cities << "\n";
        for (int i = 1; i <= n_cities; ++i) {
            std::cout << i << (i == n_cities ? "" : " ");
        }
        std::cout << "\n";
        return 0;
    }

    // 初始化BFS队列：
    // 从具有最大记录距离的城市开始。
    // 对于这些城市 c，其 derived_dist[c] 被设置为 recorded_dist[c]。
    // 城市 c 满足其自身的约束。
    if (max_recorded_dist_val >= 0) { // 确保至少有一个记录距离
        // cities_by_dist[max_recorded_dist_val] 包含所有距离酒店最远（根据记录）的城市
        for (int city_idx : cities_by_dist[max_recorded_dist_val]) {
            visited_in_bfs[city_idx] = true;
            derived_dist[city_idx] = max_recorded_dist_val;
            constraints_satisfied[city_idx].set(city_idx); // city_idx 对应其自身约束的位被置1
            q.push(city_idx);
        }
        // 清空此列表，因为这些城市已加入队列，不应在BFS内部的 target_dist 循环中再次从 cities_by_dist 中选取。
        cities_by_dist[max_recorded_dist_val].clear();
    } else {
        // 如果 num_cities_with_recorded_dist > 0 但 max_recorded_dist_val < 0 (例如所有记录距离都是0)
        // 那么应该从 recorded_dist[i] == 0 的城市开始。
        // 上述代码的 max_recorded_dist_val >= 0 已经覆盖了此情况，
        // 如果所有记录的距离都是0, max_recorded_dist_val 会是0。
        // 如果没有正的记录距离，但有记录为0的距离，max_recorded_dist_val会是0。
        // 如果没有记录，则num_cities_with_recorded_dist为0，已处理。
    }
    
    solve_bfs(); // 执行核心算法

    std::vector<int> potential_hotel_cities; // 存储可能的酒店城市编号
    if (possible_to_find_hotel) { // 只有在未发现矛盾时才查找解
        for (int i = 1; i <= n_cities; ++i) {
            // 城市 i 成为酒店的条件：
            // 1. 其推导出的到酒店的距离 (derived_dist[i]) 为 0。
            // 2. 所有 Malnar 记录的约束都得到满足 
            //    (constraints_satisfied[i] 中被设置的位数等于有记录的城市总数)。
            // 3. 如果城市 i 本身有记录距离 (recorded_dist[i] != -1)，那么该记录必须是 0。
            //    (因为如果酒店在i, i到自身的距离是0)
            bool self_constraint_ok = (recorded_dist[i] == -1 || recorded_dist[i] == 0);

            if (derived_dist[i] == 0 &&
                constraints_satisfied[i].count() == num_cities_with_recorded_dist &&
                self_constraint_ok) {
                potential_hotel_cities.push_back(i);
            }
        }
    }

    std::cout << potential_hotel_cities.size() << "\n";
    std::sort(potential_hotel_cities.begin(), potential_hotel_cities.end()); // 按升序输出
    for (size_t i = 0; i < potential_hotel_cities.size(); ++i) {
        std::cout << potential_hotel_cities[i] << (i == potential_hotel_cities.size() - 1 ? "" : " ");
    }
    // 即使列表为空，也总是输出一个换行符，满足题目两行输出的要求。
    std::cout << "\n";

    return 0;
}